<?php
/**
 * Zend Framework
 * LICENSE
 * This source file is subject to the new BSD license that is bundled
 * with this package in the file LICENSE.txt.
 * It is also available through the world-wide-web at this URL:
 * http://framework.zend.com/license/new-bsd
 * If you did not receive a copy of the license and are unable to
 * obtain it through the world-wide-web, please send an email
 * to license@zend.com so we can send you a copy immediately.
 * @category Zend
 * @package Zend_Mime
 * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 * @license http://framework.zend.com/license/new-bsd New BSD License
 * @version $Id: Message.php 24593 2012-01-05 20:35:02Z matthew $
 */
/**
 * Zend_Mime
 */
require_once 'Zend/Mime.php';
/**
 * Zend_Mime_Part
 */
require_once 'Zend/Mime/Part.php';

/**
 *
 * @category Zend
 * @package Zend_Mime
 * @copyright Copyright (c) 2005-2012 Zend Technologies USA Inc. (http://www.zend.com)
 * @license http://framework.zend.com/license/new-bsd New BSD License
 */
class Zend_Mime_Message {

    protected $_parts = array();

    protected $_mime = null;

    /**
     * Returns the list of all Zend_Mime_Parts in the message
     * @return array of Zend_Mime_Part
     */
    public function getParts () {
        return $this -> _parts;
    }

    /**
     * Sets the given array of Zend_Mime_Parts as the array for the message
     * @param array $parts
     */
    public function setParts ($parts) {
        $this -> _parts = $parts;
    }

    /**
     * Append a new Zend_Mime_Part to the current message
     * @param Zend_Mime_Part $part
     */
    public function addPart (Zend_Mime_Part $part) {
        /**
         *
         * @todo check for duplicate object handle
         */
        $this -> _parts[] = $part;
    }

    /**
     * Check if message needs to be sent as multipart
     * MIME message or if it has only one part.
     * @return boolean
     */
    public function isMultiPart () {
        return (count ($this -> _parts) > 1);
    }

    /**
     * Set Zend_Mime object for the message
     * This can be used to set the boundary specifically or to use a subclass of
     * Zend_Mime for generating the boundary.
     * @param Zend_Mime $mime
     */
    public function setMime (Zend_Mime $mime) {
        $this -> _mime = $mime;
    }

    /**
     * Returns the Zend_Mime object in use by the message
     * If the object was not present, it is created and returned.
     * Can be used to
     * determine the boundary used in this message.
     * @return Zend_Mime
     */
    public function getMime () {
        if ($this -> _mime === null) {
            $this -> _mime = new Zend_Mime ();
        }
        return $this -> _mime;
    }

    /**
     * Generate MIME-compliant message from the current configuration
     * This can be a multipart message if more than one MIME part was added.
     * If
     * only one part is present, the content of this part is returned. If no
     * part had been added, an empty string is returned.
     * Parts are seperated by the mime boundary as defined in Zend_Mime. If
     * {@link setMime()} has been called before this method, the Zend_Mime
     * object set by this call will be used. Otherwise, a new Zend_Mime object
     * is generated and used.
     * @param string $EOL EOL string; defaults to {@link Zend_Mime::LINEEND}
     * @return string
     */
    public function generateMessage ($EOL = Zend_Mime::LINEEND) {
        if ( ! $this -> isMultiPart ()) {
            $body = array_shift ($this -> _parts);
            $body = $body -> getContent ($EOL);
        } else {
            $mime = $this -> getMime ();
            $boundaryLine = $mime -> boundaryLine ($EOL);
            $body = 'This is a message in Mime Format.  If you see this, ' . "your mail reader does not support this format." . $EOL;
            foreach (array_keys ($this -> _parts) as $p) {
                $body .= $boundaryLine . $this -> getPartHeaders ($p, $EOL) . $EOL . $this -> getPartContent ($p, $EOL);
            }
            $body .= $mime -> mimeEnd ($EOL);
        }
        return trim ($body);
    }

    /**
     * Get the headers of a given part as an array
     * @param int $partnum
     * @return array
     */
    public function getPartHeadersArray ($partnum) {
        return $this -> _parts[$partnum] -> getHeadersArray ();
    }

    /**
     * Get the headers of a given part as a string
     * @param int $partnum
     * @return string
     */
    public function getPartHeaders ($partnum, $EOL = Zend_Mime::LINEEND) {
        return $this -> _parts[$partnum] -> getHeaders ($EOL);
    }

    /**
     * Get the (encoded) content of a given part as a string
     * @param int $partnum
     * @return string
     */
    public function getPartContent ($partnum, $EOL = Zend_Mime::LINEEND) {
        return $this -> _parts[$partnum] -> getContent ($EOL);
    }

    /**
     * Explode MIME multipart string into seperate parts
     * Parts consist of the header and the body of each MIME part.
     * @param string $body
     * @param string $boundary
     * @return array
     */
    protected static function _disassembleMime ($body, $boundary) {
        $start = 0;
        $res = array();
        // find every mime part limiter and cut out the
        // string before it.
        // the part before the first boundary string is discarded:
        $p = strpos ($body, '--' . $boundary . "\n", $start);
        if ($p === false) {
            // no parts found!
            return array();
        }
        // position after first boundary line
        $start = $p + 3 + strlen ($boundary);
        while (($p = strpos ($body, '--' . $boundary . "\n", $start)) !== false) {
            $res[] = substr ($body, $start, $p - $start);
            $start = $p + 3 + strlen ($boundary);
        }
        // no more parts, find end boundary
        $p = strpos ($body, '--' . $boundary . '--', $start);
        if ($p === false) {
            throw new Zend_Exception ('Not a valid Mime Message: End Missing');
        }
        // the remaining part also needs to be parsed:
        $res[] = substr ($body, $start, $p - $start);
        return $res;
    }

    /**
     * Decodes a MIME encoded string and returns a Zend_Mime_Message object with
     * all the MIME parts set according to the given string
     * @param string $message
     * @param string $boundary
     * @param string $EOL EOL string; defaults to {@link Zend_Mime::LINEEND}
     * @return Zend_Mime_Message
     */
    public static function createFromMessage ($message, $boundary, $EOL = Zend_Mime::LINEEND) {
        require_once 'Zend/Mime/Decode.php';
        $parts = Zend_Mime_Decode::splitMessageStruct ($message, $boundary, $EOL);
        $res = new self ();
        foreach ($parts as $part) {
            // now we build a new MimePart for the current Message Part:
            $newPart = new Zend_Mime_Part ($part['body']);
            foreach ($part['header'] as $key => $value) {
                /**
                 *
                 * @todo check for characterset and filename
                 */
                switch (strtolower ($key)) {
                    case 'content-type' :
                        $newPart -> type = $value;
                        break;
                    case 'content-transfer-encoding' :
                        $newPart -> encoding = $value;
                        break;
                    case 'content-id' :
                        $newPart -> id = trim ($value, '<>');
                        break;
                    case 'content-disposition' :
                        $newPart -> disposition = $value;
                        break;
                    case 'content-description' :
                        $newPart -> description = $value;
                        break;
                    case 'content-location' :
                        $newPart -> location = $value;
                        break;
                    case 'content-language' :
                        $newPart -> language = $value;
                        break;
                    default :
                        throw new Zend_Exception ('Unknown header ignored for MimePart:' . $key);
                }
            }
            $res -> addPart ($newPart);
        }
        return $res;
    }

}
